Working with Functional Interfaces in Java

Course: Core Java Training

Topic: Working with Functional Interfaces

Course Link: Core Java Training – JustAcademy

Demo Link: Register for a Free Course Demo

Website: JustAcademy Official Website

1. Introduction to Functional Interfaces

A functional interface is an interface in Java that contains exactly one abstract method. It represents a single operation that can be implemented using a lambda expression, a method reference, or an anonymous class.

Functional interfaces became especially important in Java 8 because they enabled functional programming features, making code shorter, more readable, and easier to maintain.

For example, instead of creating a separate class to implement a simple operation, a developer can use a lambda expression to provide the implementation directly.

Example

@FunctionalInterface
interface Greeting {
    void sayHello();
}

public class Main {
    public static void main(String[] args) {
        Greeting greeting = () -> System.out.println("Hello, Java!");
        greeting.sayHello();
    }
}

Output:

Hello, Java!

In this example, the Greeting interface has one abstract method named sayHello(). The lambda expression supplies its implementation without requiring a separate implementation class.

2. Learning Objectives

After studying this topic, you will be able to:

• Understand the meaning and purpose of functional interfaces.
• Identify the characteristics of a functional interface.
• Use the @FunctionalInterface annotation.
• Create custom functional interfaces.
• Implement interfaces using lambda expressions.
• Understand built-in functional interfaces in Java.
• Work with Predicate, Function, Consumer, and Supplier.
• Use functional interfaces with collections and streams.
• Recognize common errors and apply best practices.

3. What Is a Functional Interface?

A functional interface is an interface with exactly one abstract method, also known as a Single Abstract Method (SAM) interface.

The single abstract method defines the operation that a lambda expression must implement. The interface may also contain default methods, static methods, and methods corresponding to public methods of the Object class without losing its functional-interface status.

Example

@FunctionalInterface
interface Calculator {
    int calculate(int a, int b);
}

public class Main {
    public static void main(String[] args) {
        Calculator addition = (a, b) -> a + b;
        Calculator multiplication = (a, b) -> a * b;

        System.out.println(addition.calculate(10, 5));
        System.out.println(multiplication.calculate(10, 5));
    }
}

Output:

15
50

Here, the same functional interface supports different operations. Each lambda expression provides a different implementation of the calculate() method.

4. Main Characteristics of Functional Interfaces

5. Understanding the @FunctionalInterface Annotation

The @FunctionalInterface annotation tells the Java compiler that an interface is intended to be a functional interface. The compiler checks that the interface satisfies the functional-interface rules.

The annotation is optional. An interface can still be a functional interface without it, provided it meets the requirements.

Example

@FunctionalInterface
interface Printable {
    void print();

    default void showMessage() {
        System.out.println("Printing document");
    }
}

public class Main {
    public static void main(String[] args) {
        Printable printer = () -> System.out.println("Document printed");

        printer.print();
        printer.showMessage();
    }
}

Output:

Document printed
Printing document

The interface is valid because it has only one abstract method. The default method already has an implementation and does not count as another abstract method.

Invalid Functional Interface Example

@FunctionalInterface
interface InvalidExample {
    void firstMethod();
    void secondMethod();
}

This code produces a compilation error because the interface declares two abstract methods.

6. Functional Interfaces and Lambda Expressions

A lambda expression provides an implementation of the single abstract method of a functional interface. It reduces boilerplate code and allows behavior to be passed as an argument.

General Syntax

(parameters) -> expression

For multiple statements, use a block body enclosed in curly braces.

(parameters) -> {
    // Statements
    return result;
}

Example: Lambda with Parameters

@FunctionalInterface
interface Square {
    int calculate(int number);
}

public class Main {
    public static void main(String[] args) {
        Square square = number -> number * number;

        System.out.println(square.calculate(6));
    }
}

Output:

36

The lambda expression accepts one integer and returns its square. The compiler determines the target type from the Square interface.

7. Creating a Custom Functional Interface

Developers can define custom functional interfaces when the standard Java interfaces do not express the required operation clearly.

Example: Employee Bonus Calculator

@FunctionalInterface
interface BonusCalculator {
    double calculateBonus(double salary);
}

public class Main {
    public static void main(String[] args) {
        BonusCalculator bonus =
            salary -> salary * 0.10;

        double salary = 50000;
        double amount = bonus.calculateBonus(salary);

        System.out.println("Bonus: " + amount);
    }
}

Output:

Bonus: 5000.0

This custom interface makes the bonus calculation reusable. Another lambda could calculate a different bonus percentage without changing the interface.

8. Built-in Functional Interfaces in Java

Java provides several commonly used functional interfaces in the java.util.function package. These interfaces cover common programming tasks such as testing conditions, transforming values, consuming values, and supplying values.

9. Using Predicate

The Predicate<T> interface tests a condition and returns true or false. Its abstract method is test(T t).

Example

import java.util.function.Predicate;

public class Main {
    public static void main(String[] args) {
        Predicate<Integer> isEven =
            number -> number % 2 == 0;

        System.out.println(isEven.test(8));
        System.out.println(isEven.test(7));
    }
}

Output:

true
false

Predicates are particularly useful for filtering lists and checking business rules. They also provide methods such as and(), or(), and negate() for combining conditions.

10. Using Function

The Function<T,R> interface accepts an input of type T and returns a result of type R. Its main method is apply().

Example

import java.util.function.Function;

public class Main {
    public static void main(String[] args) {
        Function<String, Integer> getLength =
            text -> text.length();

        int length = getLength.apply("Java");

        System.out.println(length);
    }
}

Output:

4

Here, the input type is String, and the returned type is Integer. Functions are useful for data transformation, formatting, and converting one representation into another.

11. Using Consumer

The Consumer<T> interface accepts one input and performs an operation without returning a result. Its abstract method is accept().

Example

import java.util.function.Consumer;

public class Main {
    public static void main(String[] args) {
        Consumer<String> display =
            message -> System.out.println(message);

        display.accept("Learning Functional Interfaces");
    }
}

Output:

Learning Functional Interfaces

Consumers are commonly used for printing values, logging messages, processing collection elements, and performing actions that produce side effects.

12. Using Supplier

The Supplier<T> interface provides a value without taking any input. Its abstract method is get().

Example

import java.util.function.Supplier;

public class Main {
    public static void main(String[] args) {
        Supplier<String> message =
            () -> "Welcome to Core Java";

        System.out.println(message.get());
    }
}

Output:

Welcome to Core Java

A supplier can provide default values, create objects, or generate values on demand. The supplier's implementation determines whether each call returns a constant or a newly generated value.

13. Using UnaryOperator and BinaryOperator

UnaryOperator<T> is a specialized Function that accepts and returns the same type. BinaryOperator<T> is a specialized BiFunction in which both inputs and the result have the same type.

Example

import java.util.function.UnaryOperator;
import java.util.function.BinaryOperator;

public class Main {
    public static void main(String[] args) {
        UnaryOperator<Integer> doubleValue =
            number -> number * 2;

        BinaryOperator<Integer> add =
            (a, b) -> a + b;

        System.out.println(doubleValue.apply(5));
        System.out.println(add.apply(10, 20));
    }
}

Output:

10
30

14. Functional Interfaces with Collections

Functional interfaces work well with Java collections because methods such as forEach(), removeIf(), and sort() accept behavior through functional-interface parameters.

Example: Iterating Through a List

import java.util.Arrays;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        List<String> names =
            Arrays.asList("Amit", "Neha", "Rahul");

        names.forEach(name ->
            System.out.println(name));
    }
}

Output:

Amit
Neha
Rahul

The forEach() method accepts a Consumer. The lambda expression defines what should happen to each element.

15. Functional Interfaces with Stream API

The Java Stream API uses functional interfaces extensively to process collections declaratively. Common operations include filtering, mapping, sorting, and collecting results.

Example: Filter Even Numbers

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

public class Main {
    public static void main(String[] args) {
        List<Integer> numbers =
            Arrays.asList(1, 2, 3, 4, 5, 6);

        List<Integer> evenNumbers = numbers.stream()
            .filter(number -> number % 2 == 0)
            .collect(Collectors.toList());

        System.out.println(evenNumbers);
    }
}

Output:

[2, 4, 6]

The filter() operation accepts a Predicate. The lambda returns true for even numbers, allowing those values to pass through the stream.

Example: Transform Names

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

public class Main {
    public static void main(String[] args) {
        List<String> names =
            Arrays.asList("amit", "neha", "rahul");

        List<String> upperNames = names.stream()
            .map(name -> name.toUpperCase())
            .collect(Collectors.toList());

        System.out.println(upperNames);
    }
}

Output:

[AMIT, NEHA, RAHUL]

The map() operation uses a Function to transform each name into uppercase.

16. Method References and Functional Interfaces

A method reference is a concise alternative to a lambda expression when an existing method already performs the required operation. The referenced method must be compatible with the target functional interface.

Example

import java.util.Arrays;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        List<String> names =
            Arrays.asList("Amit", "Neha", "Rahul");

        names.forEach(System.out::println);
    }
}

Output:

Amit
Neha
Rahul

The expression System.out::println is a method reference compatible with the Consumer accepted by forEach().

17. Functional Interface vs. Normal Interface

18. Advantages of Functional Interfaces

• Less boilerplate: Lambda expressions eliminate many anonymous-class implementations.
• Improved readability: Simple operations can be expressed clearly and concisely.
• Code reusability: Behavior can be passed as an argument and reused.
• Stream integration: Functional interfaces enable declarative collection processing.
• Flexible design: Implementations can be changed without creating separate classes.
• Better composition: Some interfaces provide methods to combine operations.
• Type safety: The compiler checks input and return types against the target interface.

19. Common Mistakes and Troubleshooting

20. Best Practices

• Use @FunctionalInterface on custom interfaces to catch accidental additional abstract methods.
• Prefer built-in interfaces from java.util.function when they clearly express the required behavior.
• Choose descriptive variable names for lambda parameters.
• Keep lambda expressions short and focused on one task.
• Use method references when they make the code easier to read.
• Avoid unnecessary side effects, especially when using streams.
• Use primitive specializations such as IntPredicate or IntFunction when appropriate to reduce boxing and unboxing.
• Document custom functional interfaces when their purpose is not obvious.
• Choose meaningful input and return types to improve readability and type safety.

21. Practical Exercise

Task: Create a functional interface named NumberOperation that accepts two integers and returns an integer. Use lambda expressions to implement addition, subtraction, and multiplication.

Solution

@FunctionalInterface
interface NumberOperation {
    int operate(int a, int b);
}

public class Main {
    public static void main(String[] args) {
        NumberOperation addition =
            (a, b) -> a + b;

        NumberOperation subtraction =
            (a, b) -> a - b;

        NumberOperation multiplication =
            (a, b) -> a * b;

        System.out.println(addition.operate(12, 4));
        System.out.println(subtraction.operate(12, 4));
        System.out.println(multiplication.operate(12, 4));
    }
}

Output:

16
8
48

Additional Practice Questions

1. Create a Predicate that checks whether a number is greater than 100.
2. Create a Function that converts a string to lowercase.
3. Create a Consumer that prints employee names.
4. Create a Supplier that returns a random number.
5. Use a stream to filter names that begin with the letter A.
6. Replace a simple lambda expression with a method reference.

22. Interview Questions and Answers

Q1. What is a functional interface in Java?

A functional interface is an interface with exactly one abstract method. It can be implemented using a lambda expression or a compatible method reference.

Q2. Is the @FunctionalInterface annotation mandatory?

No. It is optional, but it allows the compiler to verify that the interface follows the functional-interface rules.

Q3. Can a functional interface contain default methods?

Yes. It can contain multiple default methods because they already have implementations.

Q4. Can a functional interface contain static methods?

Yes. Static methods with implementations do not count as additional abstract methods.

Q5. What is a SAM interface?

SAM stands for Single Abstract Method. It is another name commonly used for a functional interface.

Q6. What is the difference between Predicate and Function?

A Predicate tests a condition and returns a boolean, while a Function transforms an input into a result that may have a different type.

Q7. What is the difference between Consumer and Supplier?

A Consumer accepts an input and performs an operation without returning a result. A Supplier accepts no input and supplies a result.

Q8. Can a functional interface extend another interface?

Yes, provided the resulting interface still has exactly one distinct abstract method after accounting for inherited methods.

Q9. Can a functional interface override a method from Object?

Yes. An interface may declare an abstract method that corresponds to a public method of Object, such as toString(), without that declaration counting as an additional abstract method for functional-interface purposes.

Q10. Where are functional interfaces commonly used?

They are used with lambda expressions, method references, event handling, collection operations, callbacks, and the Stream API.

23. Quick Revision Checklist

• A functional interface has exactly one distinct abstract method.
• @FunctionalInterface enables compiler verification.
• Lambda expressions provide implementations of functional-interface methods.
• Predicate tests a condition.
• Function transforms data.
• Consumer performs an operation without returning a result.
• Supplier provides a value without input.
• UnaryOperator accepts and returns the same type.
• BinaryOperator combines two values of the same type.
• Functional interfaces are central to Java 8 streams and modern Java programming.

Conclusion

Functional interfaces are an essential feature of modern Java programming. They provide a standard way to represent individual operations and work seamlessly with lambda expressions, method references, collections, and streams. Understanding Predicate, Function, Consumer, Supplier, and custom functional interfaces helps developers write concise, flexible, reusable, and maintainable Java applications.

Practice creating functional interfaces and using them with real-world examples such as employee processing, calculations, filtering, and data transformation to strengthen your Core Java skills.

Explore Core Java Training at JustAcademy

Continue learning Java concepts through the JustAcademy Core Java Training course.

Interested in learning more? Register for a course demo to explore the training.

Visit the JustAcademy official website for additional courses and learning resources.